package yxy.cherry.battle.module.affix.skill;

import yxy.cherry.battle.Battle;
import yxy.cherry.battle.BattleFomula;
import yxy.cherry.battle.Fighter;
import yxy.cherry.battle.module.TriggerPoint;
import yxy.cherry.battle.module.affix.AffixContext;
import yxy.cherry.battle.module.affix.AffixContext.AffixActionClass;
import yxy.cherry.battle.module.affix.AffixContext.AffixTarget;
import yxy.cherry.battle.module.affix.AffixFactory.SkillTypeEnum;
import yxy.cherry.battle.module.affix.Skill;
import yxy.cherry.battle.module.affix.SkillType;
import yxy.cherry.battle.module.record.stream.*;
import yxy.cherry.data.bean.skill;

import java.util.ArrayList;
import java.util.Collection;

/** 物理攻击 */
@SkillType(Type = SkillTypeEnum.物攻)
public class Affix_02_物攻 extends Skill {

	// 参数1: 伤害比例
	// 参数2: 伤害次数
	private double get伤害比例() {
		return Double.valueOf(getParam(0)) ;
	}

	private int get伤害次数() {
		return getParam(1);
	}
	private int getAttribute() {return getParam(2);}
	private int getCalPer() {return getParam(3);}

	public Affix_02_物攻(Fighter actor, skill skilldata, int probability, int[] params) {
		super(actor, skilldata, probability, params);
	}

	private RecordStreamGroup steamGroup;

	@Override
	public RecordStreamGroup record() {
		steamGroup = getRecord().stream(new RecordStreamGroup());
		steamGroup.add(new RecordStream_SKL(getActor(), getSkillId()));
		return steamGroup;
	}

	@Override
	public boolean _exec(Collection<Fighter> targets) {
		getAffixAction().add行动类型(AffixActionClass.物理攻击);
		// 检查预设目标
		ArrayList<Fighter> targetList = new ArrayList<>();
		AffixContext.AffixAction affixAction= getAffixAction();
		if (affixAction.get目标们().size() > 0) {
			targetList.addAll(getAffixAction().get目标们Fighter());
		} else {
			targetList.addAll(targets);
			getAffixAction().setTargets(targetList);
		}

		getActor().handle阵营受攻();//主要用于援护

		boolean 有效 = false;
		for (Fighter target : getAffixAction().get目标们Fighter()) {
			有效 |= _exec(getActor(), target);
			Battle.battleLogger(6,"------------------------");
		}
		return 有效;
	}

	@Override
	public boolean exec(Fighter actor, Fighter target) {
		if (!target.is活着()) {
			return false;
		}
		getAffixAction().set针对目标(target);
		AffixTarget affixTarget = getAffixAction().getTarget(target);
		Double 附加比例 = Double.valueOf(getAffixAction().get附加比例()) ;

		RecordStream recordSteam = null;
		if (affixTarget.get援护对象() == null) {
			recordSteam = steamGroup.add(new RecordStream_02_攻击伤害(affixTarget));
		} else {
			recordSteam = steamGroup.add(new RecordStream_27_援护伤害(affixTarget));
		}

//		boolean 有效 = false;
		long 总伤害 = 0;
		boolean 有暴击 = false;

		for (int i = 0, size = get伤害次数(); i < size; i++) {
			boolean is命中 = is命中(actor, target);
			if (!is命中) {
				affixTarget.get伤害流().add(0L);
				affixTarget.getBaseDamageList().add(0L);
				affixTarget.get效果流().add(EFFECT_DODGE);
				Battle.battleLogger(6,"闪避："+actor.get命中()+"闪避："+target.get闪避());
				continue;
			}
//			有效 = true;

			//第一步：计算原始伤害
			boolean is无视防御 = actor.getAffixContext().is无视防御();
			long attackSpecial = actor.genAttackByAttribute(getAttribute(),getCalPer());
			double 原始伤害 = get伤害(actor, target, is无视防御 ,attackSpecial);


			//第二步：计算基础伤害，附加技能伤害比例(如果为追击，反击，则使用附加比例)，暴击
			Double 基础伤害 = Double.valueOf(0);
			if(isSpecialAttack()){//追击，反击等伤害方式的时候，使用附加比例进行计算
				基础伤害 = 原始伤害 * 附加比例/VALUE_比率分母;
			}else{
				基础伤害 = 原始伤害 * get伤害比例()/VALUE_比率分母;
			}
			boolean is暴击 = is暴击(actor, target);
			if (is暴击){
				基础伤害 = BattleFomula.暴击伤害(基础伤害,get暴击伤害比例(actor,target)/VALUE_比率分母);
			}
			//暂存数据，留做增伤减伤用
			affixTarget.getBaseDamageList().add(基础伤害.longValue());

			//第三步：计算最终伤害，附带增减伤、克制比例
			double 增加伤害比例 = get增加伤害比例(actor, target);
			double 克制伤害比例 = 0;
			// 克制效果
			克制伤害比例 = genSuppression(actor,target);
			//暂存数据留做增伤减伤用
			Double baseAddDamagePer = get总伤害比例(actor, target, 增加伤害比例, 克制伤害比例);
			affixTarget.setBaseAddDamagePer(baseAddDamagePer);

			Double 最终伤害 = 基础伤害 * baseAddDamagePer/VALUE_比率分母;

			long 结算伤害 = 最终伤害.longValue();

			affixTarget.get伤害流().add(结算伤害);
			affixTarget.get效果流().add(is暴击 ? EFFECT_CRIT : 0);
			if (is暴击) {
				有暴击 = true;
			}
		}
		总伤害 = affixTarget.总伤害();


		// 进攻方
		if (总伤害 > 0) {
			actor.handle攻击时();// 处理增加伤害等
			if(this.getTriggerPoint()== TriggerPoint.怒攻) {
				actor.handle怒攻时();
			}
			if(this.getTriggerPoint()== TriggerPoint.普攻) {
				actor.handle普攻时();
			}
			总伤害 = affixTarget.总伤害();
		}

		// 防守方
		if (总伤害 > 0) {
			target.handle受到攻击时();
			总伤害 = affixTarget.总伤害();
			target.set伤害(总伤害); // 殒血处理
			getAffixAction().add行动类型(AffixActionClass.有伤害);
			if (有暴击) {
				getAffixAction().add行动类型(AffixActionClass.有暴击);
			}
		}

		// 流脚本
		recordSteam.record();
		// 统计
		getRecord().get统计().getFighter(actor.getFighterPosition()).addDMG(总伤害);
		getRecord().get统计().getFighter(target.getFighterPosition()).addHUT(总伤害);

		// 输出
		if (总伤害 > 0) {
			Battle.battleLogger(6,"物理攻击："+actor.getName()+"对"+target.getName()+"造成伤害："+affixTarget.get伤害流().toString()+"攻击力："+actor.get攻击()+"防御："+target.get防御()+"暴击"+有暴击);
		} else {
			Battle.battleLogger(6,"物理攻击："+target.getName()+"：伤害为0");
		}

		if (!target.is活着()) {
			getAffixAction().add死掉的武将(target);
			getAffixAction().add行动类型(AffixActionClass.有击杀);
			actor.handle对方有死将();
			target.handle本方有死将();
		} else {
			target.handle受到攻击后();
		}

		return true;
	}


}